• Simple: It is a simple language in the sense that programs can be broken down into logical units and parts, has a rich libray support and a variety of data-types.
• Machine Independent but Platform Dependent: A C++ executable is not platform-independent (compiled programs on Linux won't run on Windows), however they are machine independent.
• Mid-level language: It is a mid-level language as we can do both systems-programming (drivers, kernels, networking etc.) and build large-scale user applications (Media Players, Photoshop, Game Engines etc.)
• Rich library support: Has a rich library support (Both standard ~ built-in data structures, algorithms etc.) as well 3rd party libraries (e.g. Boost libraries) for fast and rapid development.
• Speed of execution: C++ programs excel in execution speed. Since, it is a compiled language, and also hugely procedural. Newer languages have extra in-built default features such as grabage-collection, dynamic typing etc. which slow the execution of the program overall. Since there is no additional processing overhead like this in C++, it is blazing fast.
• Pointer and direct Memory-Access: C++ provides pointer support which aids users to directly manipulate storage address. This helps in doing low-level programming (where one might need to have explicit control on the storage of variables).
• Object-Oriented: One of the strongest points of the language which sets it apart from C. Object-Oriented support helps C++ to make maintainable and extensible programs. i.e. Large-scale applications ca be built. Procedural code becomes difficult to maintain as code-size grows.
• Compiled Language: C++ is a compiled language, contributing to its speed.

• Operating Systems & Systems Programming. e.g. Linux-based OS (Ubuntu etc.)
• Browsers (Chrome & Firefox)
• Graphics & Game engines (Photoshop, Blender, Unreal-Engine)
• Database Engines (MySQL, MongoDB, Redis etc.)
• Cloud/Distributed Systems

• Writing your program in a text-editor and saving it with correct extension(.CPP, .C, .CP)
• Compiling your program using a compiler or online IDE

Hello World

1. // Simple C++ program to display "Hello World" : This line is a comment line. A comment is used to display additional information about the program. A comment does not contain any programming logic. When a comment is encountered by a compiler, the compiler simply skips that line of code. Any line beginning with '//' without quotes OR in between /*...*/ in C++ is  comment.
2. #include: In C++,  all lines that start with pound (#) sign are called directives and are processed by preprocessor which is a program invoked by the compiler. The #include directive tells the compiler to include a file and #include<iostream> . It tells the compiler to include the standard iostream file which contains declarations of all the standard input/output library functions.
3. int main(): This line is used to declare a function named "main" which returns data of integer type. A function is a group of statements that are designed to perform a specific task. Execution of every C++ program begins with the main() function, no matter where the function is located in the program. So, every C++ program must have a main() function.
4. { and }: The opening braces '{' indicates the beginning of the main function and the closing braces '}' indicates the ending of the main function. Everything between these two comprises the body of the main function.
5. cout<<"Hello World";:  This line tells the compiler to display the message "Hello Worlld" on the screen. This line is called a statement in C++. Every statement is meant to perform some task. A semi-colon ';' is used to end a statement. Semi-colon character at the end of the statement is used to indicate that the statement is ending there.
   The cout is used to identify the standard character output device which is usually the desktop screen. Everything followed by the character "<<" is displayed to the output device.
6. return 0; : This is also a statement. This statement is used to return a value from a function and indicates the finishing of a function. This statement is basically used in functions to return the results of the operations performed by a function.
7. Indentation: As you can see the cout and the return statement have been indented or moved to the right side. This is done to make the code more readable. In a program as Hello World, it does not hold much relevance seems but as the programs become more complex, it makes the code more readable, less error-prone. Therefore, you must always use indentations and comments to make the code more readable.

• iostream: iostream stands for standard input output stream. This header file contains definitions to objects like cin, cout, cerr etc.
• iomanip: iomanip stands for input output manipulators. The methods declared in this files are used for manipulating streams. This file contains definitions of setw, setprecision etc.
• fstream: This header file mainly describes the file stream. This header file is used to handle the data being read from a file as input or data being written into the file as output.

• Standard output stream (cout): Usually the standard output device is the display screen. cout is the instance of the ostream class. cout is used to produce output on the standard output device which is usually the display screen. The data needed to be displayed on the screen is inserted in the standard output stream (cout) using the insertion operator (<<).
  
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  GeeksforGeeks - A computer science portal for geeks

  
  As you can see in the above program the insertion operator(<<) insert the value of the string variable sample followed by the string "A computer science portal for geeks" in the standard output stream cout which is then displayed on screen.
• standard input stream (cin): Usually the input device is the keyboard. cin is the instance of the class istream and is used to read input from the standard input device which is usually the keyboard.
  The extraction operator(>>) is used along with the object cin for reading inputs. The extraction operator extracts the data from the object cin which is entered using the keboard.
  
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  Run

  Output:
  

  Enter your age:
  Input : 18
  
  Your age is: 18
  

  
  The above program asks the user to input the age. The object cin is connected to the input device. The age entered by the user is extracted from cin using the extraction operator(>>) and the extracted data is then stored in the variable age present on the right side of the extraction operator.
• Un-buffered standard error stream (cerr): cerr is the standard error stream which is used to output the errors. This is also an instance of the ostream class. As cerr is un-buffered so it is used when we need to display the error message immediately. It does not have any buffer to store the error message and display later.
  
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  An error occured
  
  

• buffered standard error stream (clog): This is also an instance of the ostream class and used to display errors but unlike cerr the error is first inserted into a buffer and is stored in the buffer until it is not fully filled. The error message will be displayed on the screen too.
  
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  An error occured
  
  

Hello World!

A preprocessor directive is a statement which gets processed by the C++ preprocessor before compilation.

1. #include directive: This type of preprocessor directive tells the compiler to include a file in the source code program and are also known as File Inclusion preprocessor directives. There are two types of files which can be included by the user in the program:
   
   • Header File or Standard files: These files contains definition of pre-defined functions like printf(), scanf() etc. These files must be included for working with these functions. Different function are declared in different header files. For example standard I/O funuctions are in 'iostream' file whereas functions which perform string operations are in 'string' file.
     

     #include <file_name>
     

     where file_name is the name of file to be included. The '<' and '>' brackets tells the compiler to look for the file in standard directory.
     
   • User-defined Files: When a program becomes very large, it is good practice to divide it into smaller files and include whenever needed. These types of files are user defined files. These files can be included as:
     

     #include "filename"
     

   
   The #include directive instructs the preprocessor to fetch the contents of the file encapsulated within the quotes/arrow and placing it in the source file before compilation (simple copy-paste in layman terms). Some of the important includes are listed below:
   
   • #include < iostream >: Defines input/output stream objects (cin, cout etc.)
   • #include < cstdio >: C-standard input/output functions (printf, scanf, fscanf, fprintf, fgets etc.)
     
   • #include < cstdlib >: General purpose utilities functions (random number generation, dynamic memory allocation, integer arithmetic, conversions) (atoi, rand, srand, calloc, malloc)
     
   • #include < bits/stdc++.h >: Master directive to include all standard header files. (Note that it is not a standard header file and might not be available in compilers other than GCC)
     
   • #include "user-defined-file": When we use quotes instead of arrows, we instruct to include user-defined files (.h, .cpp). (useful in projects where one needs to keep custom-functions together)
     
   
   
2. #define directive: This directive is used to declare MACROs in the program. A MACRO is a piece of code which is designated a name. When the file is processed by the preprocessor, all appearances of the MACRO name gets replaced by its definition.
   
   Example:
   
   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   
   Output:

   Perimeter of Circle: 31.4159
   Area of Circle: 78.5398
   

   Each appearance gets replaced by the value of PI, resulting in (2 * 3.14159265 * r) and (3.14159265 * r * r). Some of the better use-cases of the #define directive can be found in competitive-programming. Such declarations at the beginning of the program greatly increases coding speed (during competitions & placement tests).
   

   #define f(l,r) for (int i = l; i < r; i++)
   #define ll long long
   #define ull unsigned long long
   #define abs(x) (x < 0 ? (-x) : x)
   

• Integer: Keyword used for integer data types is int. Integers typically require 4 bytes of memory space and range from -2147483648 to 2147483647.
• Character: Character data type is used for storing characters. Keyword used for the character data type is char. Characters typically require 1 byte of memory space and range from -128 to 127 or 0 to 255.
• Boolean: Boolean data type is used for storing boolean or logical values. A boolean variable can store either true or false. Keyword used for the boolean data type is bool.
• Floating Point: Floating Point data type is used for storing single precision floating point values or decimal values. Keyword used for floating point data type is a float. Float variables typically require 4 bytes of memory space.
• Double Floating Point: Double Floating Point data type is used for storing double precision floating point values or decimal values. Keyword used for the double floating point data type is double. Double variables typically require 8 bytes of memory space.
• void: Void means without any value. void datatype represents a valueless entity. The void data type is used for those function which does not return a value.
• Wide Character: Wide character data type is also a character data type but this data type has a size greater than the normal 8-bit datatype. Represented by wchar_t. It is generally 2 or 4 bytes long.

Variables Contd.

1. A variable name can begin only with an underscore or an alphabet (any case).
2. It can thereafter consist of any number of _, alphabets and numbers.
3. No special characters other than _ is allowed.
4. Depending on C++ implementations, there can be limitations to the length of variable name too. (e.g. Microsoft C++: 2048 characters)

• Variable declaration refers to the moment when a variable is first declared/introduced to the program.
• Definition is the part where that particular variable is allocated a storage location in memory. Initially, if the user doesn't provide any explicit, it picks up whatever garbage value was present (in case of a local variable). In case of global and static variables are assigned by default 0 and NULL values even if not explicitly stated.
• Initialization is the moment when the user explicitly assigns a value to the variable.

Scope of Variables

• Local Variables: Variables defined inside a function/block are local variables. They can't be accessed outside that particular function/block. Local variables also have a lifetime equal to that of the function/block execution. i.e. They are allocated on stack and as soon as control exits the function/block, they are de-allocated. An example showing the scope of a local variable is given below:
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  Compilation Error:
  prog.cpp: In function 'int main()':
  prog.cpp:14:37: error: 'age' was not declared in this scope
       cout << "Outside Function: " << age << endl; 
                                       ^
  

  
  The above program won't compile because of we access variable age in line: 14, which is out of the scope of the function where age is declared.
  
• Global Variables
  As the name suggests, they can be accessed in any part of the program. They are defined at the top of the program after the include directives, outside any function. They are not allocated inside any function stack. Instead, they are allocated on the Initialized/Uninitialized segment of Program Memory. Thus, they have a lifetime equal to that of the whole program. Example:
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  Access inside func: 10
  Access inside main: 10
  

  
  

Value of global x is 5
Value of local x is 10

Data-type Modifiers

• signed
• unsigned
• short
• long

1. Implicit Type Conversion Also known as ‘automatic type conversion’.
   
   
   • Done by the compiler on its own, without any external trigger from the user.
   • Generally takes place when in an expression more than one data type is present. In such condition type conversion (type promotion) takes place to avoid lose of data.
   
   
   • All the data types of the variables are upgraded to the data type of the variable with largest data type.
     
     

     bool -> char -> short int -> int -> 
     
     unsigned int -> long -> unsigned -> 
     
     long long -> float -> double -> long double
     

   
   
   • It is possible for implicit conversions to lose information, signs can be lost (when signed is implicitly converted to unsigned), and overflow can occur (when long long is implicitly converted to float).
   
   Example of Type Implicit Conversion:
   
   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   
   Output:

   x = 107
   y = a
   z = 108
   

   
   



2. Explicit Type Conversion: This process is also called type casting and it is user-defined. Here the user can typecast the result to make it of a particular data type.
   
   In C++, it can be done by two ways:
   
   • Converting by assignment: This is done by explicitly defining the required type in front of the expression in parenthesis. This can be also considered as forceful casting.
     
     Syntax:

     (type) expression

     where type indicates the data type to which the final result is converted.
     
     Example:
     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     Run
     
     Output:

     Sum = 2
     

     
     
   
   
   • Conversion using Cast operator: A Cast operator is an unary operator which forces one data type to be converted into another data type.
     C++ supports four types of casting:
     
     1. Static Cast - This is used for ordinary/normal type conversion. It does implicit type conversions (e.g. float to int, void* to int*). Example:
        
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        Run
        
        Output:

        3
        

     2. Dynamic Cast - Used for handling polymorphism. One can assign derived class object to parent/base class reference using this casting. e.g. We have a pointer to Base Class, but we want to access members defined only in Derived Class.
        
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        Run
        
        Output:

        I'm in Child
        

     3. Const Cast - This is used to add/remove constness of a variable.
        
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        Run
        
        Output:

        Old roll number: 3
        New roll number: 5
        

     
     
     4. Reinterpret Cast - It is the most dangerous cast, which should be used sparingly. It turns one type directly into another without a safety check. (e.g. one can store pointer value to an int).
        
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        Run

     
     

• This is done to take advantage of certain features of type hierarchies or type representations.
• It helps to compute expressions containing variables of different data types.

c = a + b;

• Unary - a++, !flag
• Binary - a + b, a * b
• Ternary - (test) ? value1: value2

• a = b
• a += b (a = a + b)
• a -= b (a = a - b)
• a *= b (a = a * b)
• a /= b (a = a / b)
An example usage of the above operators is given:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Run

Output:

Add & Assign: 18
Subtract & Assign: 12
Multiply & Assign: 72
Divide & Assign: 12



• a %= b (a = a % b)
% is the modulo operator (calculates remainder when a is divided by b). As an example:


int a = 10, b = 2, c = 4;
a %= b; // a = (10 % 2) = 0
a %= c;  //a = (10 % 4) = 2

• a &= b (a = a & b)
• a |= b (a = a | b)
• a ^= b (a = a ^ b)
• a <<= b (a = a << b)
• a >>= b (a = a >> b)
An example usage of the above bitwise-assignments is given below:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Run

Output:

AND & Assign: 4
OR & Assign: 6
XOR & Assign: 15
Left-shift & Assign: 30
Right-shift & Assign: 15

• Pre-Increment: Increments/decrements the value of the operand first and then returns a reference to the modified value. ++a, --a
• Post-Increment: Increment/decrement is postponed till the statement execution. Afterwards the value of the variable is modified. a++, a--

6
6
7

• +a (unary plus)
• -a (unary minus => negates the value: 5 becomes -5)
• a + b
• a - b
• a * b
• a / b
• a % b (get reminder when a is divided by b). e.g.
  

  (20 % 3) = 2
  

• ~ a (bitwise NOT, reverses all the bits)
  

  (~ 20) = -21
  20 in binary (8-bit): 00010100
  (~ 20): 11101011, which is -21 in 2's complement form 
  for negative integers.
  

• a & b (bitwise AND)
• a | b (bitwise OR)
• a ^ b (bitwise XOR)
• a << b (bitwise left shift a by b places).e.g.
  

  (5 << 2) = 20
  5 in binary: 101
  left-shift by 2 places: 10100 ~ 20 (in decimal)
  

• a >> b (bitwise right shift a by b places). e.g.
  

  (30 >> 3) = 3
  30 in binary: 11110
  right-shift by 3 places: 11 ~ 3 (in decimal)
  

• a == b
• a != b
• a < b
• a > b
• a <= b
• a >= b

a == b: 0
a != b: 1
a < b: 1
a > b: 0
a <= c: 1
b >= c: 1

• !a (negate boolean variable)
• (a && b), also (a and b) => Boolean AND
• (a || b), also (a or b) => Boolean OR

Negation: 0
AND: 0
OR: 1
1
0
1

• a[b] (access b^th element of array a)
• *a (access data value at location pointed at by a)
• &a (storage address of variable a)
Below given is a program showing the usage of the above 3 operators:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Run

Output:

4th element of the array (0-indexing): 4
Access via Pointer: 6
Value changed via pointer: 5
Address of b: 0x7ffdc51518d4



• a->b (access member variable using pointer)
• a.b (access member variable using instance)
• *(a->b) (access data value of member pointer variable using pointer)
• *(a.b) (access data value of member pointer variable using instance)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Run

Output:

Direct Access: 5
Pointer Access: 5
Direct Access of Pointer: 10
Pointer Access of Pointer: 10

Operator Precedence

• Problem 1) Change the case of the character entered. (using operators only).
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  Character p changed to: P
  Character P changed to: p
  

  In the above program, we use ternary-operator to output the character with changed case. If the character ch entered lies between 'a' and 'z', it means it is in lower-case, so we output: (ch - 'a' + 'A'), otherwise, we output (ch - 'A' + 'a').
  
  
• Problem 2) Write a program to convert temperature given in Celsius (user input) to Fahrenheit.
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  47 deg Celsius in Fahrenheit: 116.6
  29 deg Celsius in Fahrenheit: 84.2
  

  The above program is a good example of implicit type-casting in C++. Conversion of temperatures is a floating point operation. Thus, we need to have one operand as a double. i.e. 9.0 here. Otherwise, (9/5) would yield 1 and not 1.8. Once, we have converted the literal operands to a double, automatically cel1 and cel2 gets type-casted. This behaviour is also termed as up-casting.
  


• Problem 3) Write a program to find the area of a triangle. Take the length of sides as user input. (Area printed should be rounded off to two decimal places).
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  24.00
  

  Above program uses Heron's formula for calculating the area of a triangle. Similar to the previous example, we here divide by 2.0 to upcast the integral lengths to yield a final double s value.
  


• Problem 4) Take user input amount of money and consider an infinite supply of denominations 1, 20, 50 and 100. What is the minimum number of denominations to make the change?
  
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  Min. notes to get a sum of 253: 6
  

  In this problem, we have been given the relaxation of having an unlimited supply of the said denominations. Hence, to make it possible with the minimum number of notes in total, we try to accommodate the sum in the decreasing order of value. i.e. We try out first with 100, then the remaining amount with 50, then 20 and finally the remaining amount can be made up using 1s.